home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Utilities / byacc 1.8.2 / skeleton.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-04  |  14.8 KB  |  545 lines  |  [TEXT/R*ch]
  1. #include "defs.h"
  2.  
  3. /*  The banner used here should be replaced with an #ident directive    */
  4. /*  if the target C compiler supports #ident directives.                */
  5. /*                                                                      */
  6. /*  If the skeleton is changed, the banner should be changed so that    */
  7. /*  the altered version can easily be distinguished from the original.  */
  8.  
  9. static char *c_banner[] =
  10. {
  11.     "#ifndef lint",
  12.     "static char yysccsid[] = \"@(#)yaccpar 1.8 (Berkeley) 01/20/91\";",
  13.     "#endif",
  14.     "#define YYBYACC 1",
  15.     (char *) NULL
  16. };
  17.  
  18. static char *perl_banner[] =
  19. {
  20.     "$yysccsid = \"@(#)yaccpar 1.8 (Berkeley) 01/20/91 (Perl 2.0 12/31/92)\";",
  21.     "#define YYBYACC 1",
  22.     (char *) NULL
  23. };
  24.   
  25. char **banner[] = { c_banner, perl_banner };
  26.  
  27. static char *c_tables[] =
  28. {
  29.     "extern short yylhs[];",
  30.     "extern short yylen[];",
  31.     "extern short yydefred[];",
  32.     "extern short yydgoto[];",
  33.     "extern short yysindex[];",
  34.     "extern short yyrindex[];",
  35.     "extern short yygindex[];",
  36.     "extern short yytable[];",
  37.     "extern short yycheck[];",
  38.     "#if YYDEBUG",
  39.     "extern char *yyname[];",
  40.     "extern char *yyrule[];",
  41.     "#endif",
  42.     (char *) NULL
  43. };
  44.  
  45. char **tables[] = { c_tables, (char **) NULL };
  46.  
  47. static char *c_header[] =
  48. {
  49.     "#define yyclearin (yychar=(-1))",
  50.     "#define yyerrok (yyerrflag=0)",
  51.     "#ifdef YYSTACKSIZE",
  52.     "#ifndef YYMAXDEPTH",
  53.     "#define YYMAXDEPTH YYSTACKSIZE",
  54.     "#endif",
  55.     "#else",
  56.     "#ifdef YYMAXDEPTH",
  57.     "#define YYSTACKSIZE YYMAXDEPTH",
  58.     "#else",
  59.     "#define YYSTACKSIZE 500",
  60.     "#define YYMAXDEPTH 500",
  61.     "#endif",
  62.     "#endif",
  63.     "int yydebug;",
  64.     "int yynerrs;",
  65.     "int yyerrflag;",
  66.     "int yychar;",
  67.     "short *yyssp;",
  68.     "YYSTYPE *yyvsp;",
  69.     "YYSTYPE yyval;",
  70.     "YYSTYPE yylval;",
  71.     "short yyss[YYSTACKSIZE];",
  72.     "YYSTYPE yyvs[YYSTACKSIZE];",
  73.     "#define yystacksize YYSTACKSIZE",
  74.     (char *) NULL
  75. };
  76.  
  77. static char *perl_header[] =
  78. {
  79.     "sub yyclearin { $yychar = -1; }",
  80.     "sub yyerrok { $yyerrflag = 0; }",
  81.     "$YYSTACKSIZE = $YYSTACKSIZE || $YYMAXDEPTH || 500;",
  82.     "$YYMAXDEPTH = $YYMAXDEPTH || $YYSTACKSIZE || 500;",
  83.     "$yyss[$YYSTACKSIZE] = 0;",
  84.     "$yyvs[$YYSTACKSIZE] = 0;",
  85.     (char *) NULL
  86. };
  87.  
  88. char **header[] = { c_header, perl_header };
  89.  
  90. static char *c_body[] =
  91. {
  92.     "#define YYABORT goto yyabort",
  93.     "#define YYACCEPT goto yyaccept",
  94.     "#define YYERROR goto yyerrlab",
  95.     "int",
  96.     "yyparse()",
  97.     "{",
  98.     "    register int yym, yyn, yystate;",
  99.     "#if YYDEBUG",
  100.     "    register char *yys;",
  101.     "    extern char *getenv();",
  102.     "",
  103.     "    if (yys = getenv(\"YYDEBUG\"))",
  104.     "    {",
  105.     "        yyn = *yys;",
  106.     "        if (yyn >= '0' && yyn <= '9')",
  107.     "            yydebug = yyn - '0';",
  108.     "    }",
  109.     "#endif",
  110.     "",
  111.     "    yynerrs = 0;",
  112.     "    yyerrflag = 0;",
  113.     "    yychar = (-1);",
  114.     "",
  115.     "    yyssp = yyss;",
  116.     "    yyvsp = yyvs;",
  117.     "    *yyssp = yystate = 0;",
  118.     "",
  119.     "yyloop:",
  120.     "    if (yyn = yydefred[yystate]) goto yyreduce;",
  121.     "    if (yychar < 0)",
  122.     "    {",
  123.     "        if ((yychar = yylex()) < 0) yychar = 0;",
  124.     "#if YYDEBUG",
  125.     "        if (yydebug)",
  126.     "        {",
  127.     "            yys = 0;",
  128.     "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  129.     "            if (!yys) yys = \"illegal-symbol\";",
  130.     "            printf(\"yydebug: state %d, reading %d (%s)\\n\", yystate,",
  131.     "                    yychar, yys);",
  132.     "        }",
  133.     "#endif",
  134.     "    }",
  135.     "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
  136.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
  137.     "    {",
  138.     "#if YYDEBUG",
  139.     "        if (yydebug)",
  140.     "            printf(\"yydebug: state %d, shifting to state %d\\n\",",
  141.     "                    yystate, yytable[yyn]);",
  142.     "#endif",
  143.     "        if (yyssp >= yyss + yystacksize - 1)",
  144.     "        {",
  145.     "            goto yyoverflow;",
  146.     "        }",
  147.     "        *++yyssp = yystate = yytable[yyn];",
  148.     "        *++yyvsp = yylval;",
  149.     "        yychar = (-1);",
  150.     "        if (yyerrflag > 0)  --yyerrflag;",
  151.     "        goto yyloop;",
  152.     "    }",
  153.     "    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&",
  154.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
  155.     "    {",
  156.     "        yyn = yytable[yyn];",
  157.     "        goto yyreduce;",
  158.     "    }",
  159.     "    if (yyerrflag) goto yyinrecovery;",
  160.     "#ifdef lint",
  161.     "    goto yynewerror;",
  162.     "#endif",
  163.     "yynewerror:",
  164.     "    yyerror(\"syntax error\");",
  165.     "#ifdef lint",
  166.     "    goto yyerrlab;",
  167.     "#endif",
  168.     "yyerrlab:",
  169.     "    ++yynerrs;",
  170.     "yyinrecovery:",
  171.     "    if (yyerrflag < 3)",
  172.     "    {",
  173.     "        yyerrflag = 3;",
  174.     "        for (;;)",
  175.     "        {",
  176.     "            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&",
  177.     "                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)",
  178.     "            {",
  179.     "#if YYDEBUG",
  180.     "                if (yydebug)",
  181.     "                    printf(\"yydebug: state %d, error recovery shifting\\",
  182.     " to state %d\\n\", *yyssp, yytable[yyn]);",
  183.     "#endif",
  184.     "                if (yyssp >= yyss + yystacksize - 1)",
  185.     "                {",
  186.     "                    goto yyoverflow;",
  187.     "                }",
  188.     "                *++yyssp = yystate = yytable[yyn];",
  189.     "                *++yyvsp = yylval;",
  190.     "                goto yyloop;",
  191.     "            }",
  192.     "            else",
  193.     "            {",
  194.     "#if YYDEBUG",
  195.     "                if (yydebug)",
  196.     "                    printf(\"yydebug: error recovery discarding state %d\
  197. \\n\",",
  198.     "                            *yyssp);",
  199.     "#endif",
  200.     "                if (yyssp <= yyss) goto yyabort;",
  201.     "                --yyssp;",
  202.     "                --yyvsp;",
  203.     "            }",
  204.     "        }",
  205.     "    }",
  206.     "    else",
  207.     "    {",
  208.     "        if (yychar == 0) goto yyabort;",
  209.     "#if YYDEBUG",
  210.     "        if (yydebug)",
  211.     "        {",
  212.     "            yys = 0;",
  213.     "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  214.     "            if (!yys) yys = \"illegal-symbol\";",
  215.     "            printf(\"yydebug: state %d, error recovery discards token %d\
  216.  (%s)\\n\",",
  217.     "                    yystate, yychar, yys);",
  218.     "        }",
  219.     "#endif",
  220.     "        yychar = (-1);",
  221.     "        goto yyloop;",
  222.     "    }",
  223.     "yyreduce:",
  224.     "#if YYDEBUG",
  225.     "    if (yydebug)",
  226.     "        printf(\"yydebug: state %d, reducing by rule %d (%s)\\n\",",
  227.     "                yystate, yyn, yyrule[yyn]);",
  228.     "#endif",
  229.     "    yym = yylen[yyn];",
  230.     "    yyval = yyvsp[1-yym];",
  231.     "    switch (yyn)",
  232.     "    {",
  233.     (char *) NULL
  234. };
  235.  
  236. static char *perl_body[] =
  237. {
  238.     "sub YYERROR { ++$yynerrs; &yy_err_recover; }",
  239.     "sub yy_err_recover",
  240.     "{",
  241.     "  if ($yyerrflag < 3)",
  242.     "  {",
  243.     "    $yyerrflag = 3;",
  244.     "    while (1)",
  245.     "    {",
  246.     "      if (($yyn = $yysindex[$yyss[$yyssp]]) && ",
  247.     "          ($yyn += $YYERRCODE) >= 0 && ",
  248.     "          $yycheck[$yyn] == $YYERRCODE)",
  249.     "      {",
  250.     "#if YYDEBUG",
  251.     "       print \"yydebug: state $yyss[$yyssp], error recovery shifting\",",
  252.     "             \" to state $yytable[$yyn]\\n\" if $yydebug;",
  253.     "#endif",
  254.     "        $yyss[++$yyssp] = $yystate = $yytable[$yyn];",
  255.     "        $yyvs[++$yyvsp] = $yylval;",
  256.     "        next yyloop;",
  257.     "      }",
  258.     "      else",
  259.     "      {",
  260.     "#if YYDEBUG",
  261.     "        print \"yydebug: error recovery discarding state \",",
  262.     "              $yyss[$yyssp], \"\\n\"  if $yydebug;",
  263.     "#endif",
  264.     "        return(1) if $yyssp <= 0;",
  265.     "        --$yyssp;",
  266.     "        --$yyvsp;",
  267.     "      }",
  268.     "    }",
  269.     "  }",
  270.     "  else",
  271.     "  {",
  272.     "    return (1) if $yychar == 0;",
  273.     "#if YYDEBUG",
  274.     "    if ($yydebug)",
  275.     "    {",
  276.     "      $yys = '';",
  277.     "      if ($yychar <= $YYMAXTOKEN) { $yys = $yyname[$yychar]; }",
  278.     "      if (!$yys) { $yys = 'illegal-symbol'; }",
  279.     "      print \"yydebug: state $yystate, error recovery discards \",",
  280.     "            \"token $yychar ($yys)\\n\";",
  281.     "    }",
  282.     "#endif",
  283.     "    $yychar = -1;",
  284.     "    next yyloop;",
  285.     "  }",
  286.     "0;",
  287.     "} # yy_err_recover",
  288.     "",
  289.     "sub yyparse",
  290.     "{",
  291.     "#ifdef YYDEBUG",
  292.     "  if ($yys = $ENV{'YYDEBUG'})",
  293.     "  {",
  294.     "    $yydebug = int($1) if $yys =~ /^(\\d)/;",
  295.     "  }",
  296.     "#endif",
  297.     "",
  298.     "  $yynerrs = 0;",
  299.     "  $yyerrflag = 0;",
  300.     "  $yychar = (-1);",
  301.     "",
  302.     "  $yyssp = 0;",
  303.     "  $yyvsp = 0;",
  304.     "  $yyss[$yyssp] = $yystate = 0;",
  305.     "",
  306.     "yyloop: while(1)",
  307.     "  {",
  308.     "    yyreduce: {",
  309.     "      last yyreduce if ($yyn = $yydefred[$yystate]);",
  310.     "      if ($yychar < 0)",
  311.     "      {",
  312.     "        if (($yychar = &yylex) < 0) { $yychar = 0; }",
  313.     "#if YYDEBUG",
  314.     "        if ($yydebug)",
  315.     "        {",
  316.     "          $yys = '';",
  317.     "          if ($yychar <= $#yyname) { $yys = $yyname[$yychar]; }",
  318.     "          if (!$yys) { $yys = 'illegal-symbol'; };",
  319.     "          print \"yydebug: state $yystate, reading $yychar ($yys)\\n\";",
  320.     "        }",
  321.     "#endif",
  322.     "      }",
  323.     "      if (($yyn = $yysindex[$yystate]) && ($yyn += $yychar) >= 0 &&",
  324.     "              $yycheck[$yyn] == $yychar)",
  325.     "      {",
  326.     "#if YYDEBUG",
  327.     "        print \"yydebug: state $yystate, shifting to state \",",
  328.     "              $yytable[$yyn], \"\\n\"  if $yydebug;",
  329.     "#endif",
  330.     "        $yyss[++$yyssp] = $yystate = $yytable[$yyn];",
  331.     "        $yyvs[++$yyvsp] = $yylval;",
  332.     "        $yychar = (-1);",
  333.     "        --$yyerrflag if $yyerrflag > 0;",
  334.     "        next yyloop;",
  335.     "      }",
  336.     "      if (($yyn = $yyrindex[$yystate]) && ($yyn += $yychar) >= 0 &&",
  337.     "            $yycheck[$yyn] == $yychar)",
  338.     "      {",
  339.     "        $yyn = $yytable[$yyn];",
  340.     "        last yyreduce;",
  341.     "      }",
  342.     "      if (! $yyerrflag) {",
  343.     "        &yyerror('syntax error');",
  344.     "        ++$yynerrs;",
  345.     "      }",
  346.     "      return(1) if &yy_err_recover;",
  347.     "    } # yyreduce",
  348.     "#if YYDEBUG",
  349.     "    print \"yydebug: state $yystate, reducing by rule \",",
  350.     "          \"$yyn ($yyrule[$yyn])\\n\"  if $yydebug;",
  351.     "#endif",
  352.     "    $yym = $yylen[$yyn];",
  353.     "    $yyval = $yyvs[$yyvsp+1-$yym];",
  354.     "    switch:",
  355.     "    {",
  356.     (char *) NULL
  357. };
  358.  
  359. char **body[] = { c_body, perl_body };
  360.  
  361. static char *c_trailer[] =
  362. {
  363.     "    }",
  364.     "    yyssp -= yym;",
  365.     "    yystate = *yyssp;",
  366.     "    yyvsp -= yym;",
  367.     "    yym = yylhs[yyn];",
  368.     "    if (yystate == 0 && yym == 0)",
  369.     "    {",
  370.     "#if YYDEBUG",
  371.     "        if (yydebug)",
  372.     "            printf(\"yydebug: after reduction, shifting from state 0 to\\",
  373.     " state %d\\n\", YYFINAL);",
  374.     "#endif",
  375.     "        yystate = YYFINAL;",
  376.     "        *++yyssp = YYFINAL;",
  377.     "        *++yyvsp = yyval;",
  378.     "        if (yychar < 0)",
  379.     "        {",
  380.     "            if ((yychar = yylex()) < 0) yychar = 0;",
  381.     "#if YYDEBUG",
  382.     "            if (yydebug)",
  383.     "            {",
  384.     "                yys = 0;",
  385.     "                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  386.     "                if (!yys) yys = \"illegal-symbol\";",
  387.     "                printf(\"yydebug: state %d, reading %d (%s)\\n\",",
  388.     "                        YYFINAL, yychar, yys);",
  389.     "            }",
  390.     "#endif",
  391.     "        }",
  392.     "        if (yychar == 0) goto yyaccept;",
  393.     "        goto yyloop;",
  394.     "    }",
  395.     "    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
  396.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)",
  397.     "        yystate = yytable[yyn];",
  398.     "    else",
  399.     "        yystate = yydgoto[yym];",
  400.     "#if YYDEBUG",
  401.     "    if (yydebug)",
  402.     "        printf(\"yydebug: after reduction, shifting from state %d \\",
  403.     "to state %d\\n\", *yyssp, yystate);",
  404.     "#endif",
  405.     "    if (yyssp >= yyss + yystacksize - 1)",
  406.     "    {",
  407.     "        goto yyoverflow;",
  408.     "    }",
  409.     "    *++yyssp = yystate;",
  410.     "    *++yyvsp = yyval;",
  411.     "    goto yyloop;",
  412.     "yyoverflow:",
  413.     "    yyerror(\"yacc stack overflow\");",
  414.     "yyabort:",
  415.     "    return (1);",
  416.     "yyaccept:",
  417.     "    return (0);",
  418.     "}",
  419.     (char *) NULL
  420. };
  421.  
  422. static char *perl_trailer[] =
  423. {
  424.     "    } # switch",
  425.     "    $yyssp -= $yym;",
  426.     "    $yystate = $yyss[$yyssp];",
  427.     "    $yyvsp -= $yym;",
  428.     "    $yym = $yylhs[$yyn];",
  429.     "    if ($yystate == 0 && $yym == 0)",
  430.     "    {",
  431.     "#if YYDEBUG",
  432.     "      print \"yydebug: after reduction, shifting from state 0 \",",
  433.     "            \"to state $YYFINAL\\n\" if $yydebug;",
  434.     "#endif",
  435.     "      $yystate = $YYFINAL;",
  436.     "      $yyss[++$yyssp] = $YYFINAL;",
  437.     "      $yyvs[++$yyvsp] = $yyval;",
  438.     "      if ($yychar < 0)",
  439.     "      {",
  440.     "        if (($yychar = &yylex) < 0) { $yychar = 0; }",
  441.     "#if YYDEBUG",
  442.     "        if ($yydebug)",
  443.     "        {",
  444.     "          $yys = '';",
  445.     "          if ($yychar <= $#yyname) { $yys = $yyname[$yychar]; }",
  446.     "          if (!$yys) { $yys = 'illegal-symbol'; }",
  447.     "          print \"yydebug: state $YYFINAL, reading $yychar ($yys)\\n\";",
  448.     "        }",
  449.     "#endif",
  450.     "      }",
  451.     "      return(0) if $yychar == 0;",
  452.     "      next yyloop;",
  453.     "    }",
  454.     "    if (($yyn = $yygindex[$yym]) && ($yyn += $yystate) >= 0 &&",
  455.     "        $yyn <= $#yycheck && $yycheck[$yyn] == $yystate)",
  456.     "    {",
  457.     "        $yystate = $yytable[$yyn];",
  458.     "    } else {",
  459.     "        $yystate = $yydgoto[$yym];",
  460.     "    }",
  461.     "#if YYDEBUG",
  462.     "    print \"yydebug: after reduction, shifting from state \",",
  463.     "        \"$yyss[$yyssp] to state $yystate\\n\" if $yydebug;",
  464.     "#endif",
  465.     "    $yyss[++$yyssp] = $yystate;",
  466.     "    $yyvs[++$yyvsp] = $yyval;",
  467.     "  } # yyloop",
  468.     "} # yyparse",
  469.     (char *) NULL
  470. };
  471.  
  472. char **trailer[] = { c_trailer, perl_trailer };
  473.  
  474. #if __STDC__
  475. static char *add_prefixes(char *old_str, char *new_str)
  476. #else
  477. static char *add_prefixes(old_str, new_str)
  478. char *old_str;
  479. char *new_str;
  480. #endif
  481. {
  482.     register char *from = old_str;
  483.     register char *to = new_str;
  484.     register char *p;
  485.  
  486.     while (*from) {
  487.     if (*from == 'Y' && *(from + 1) == 'Y') {
  488.         from += 2;
  489.         p = define_prefix;
  490.         while (*to++ = *p++)
  491.         /* void */ ;
  492.         to--;
  493.     }
  494.     else if (*from == 'y' && *(from + 1) == 'y') {
  495.         from += 2;
  496.         p = symbol_prefix;
  497.         while (*to++ = *p++)
  498.         /* void */ ;
  499.         to--;
  500.     }
  501.     else {
  502.         *to++ = *from++;
  503.     }
  504.     }
  505.  
  506.     *to = *from;
  507.     
  508.     return new_str;
  509. }
  510.  
  511. #if __STDC__
  512. void write_section(char **section[])
  513. #else
  514. void write_section(section)
  515. char **section[];
  516. #endif
  517. {
  518.     register int i;
  519.     register FILE *fp;
  520.     register char **sec = section[(int) language];
  521.  
  522.     if (sec != (char **) NULL)
  523.     {
  524.     fp = code_file;
  525.     if (prefix_changed)
  526.     {
  527.         char buf[BUFSIZ];
  528.  
  529.         for (i = 0; sec[i]; ++i)
  530.         {
  531.         ++outline;
  532.         fprintf(fp, "%s\n", add_prefixes(sec[i], buf));
  533.         }
  534.     }
  535.     else
  536.     {
  537.         for (i = 0; sec[i]; ++i)
  538.         {
  539.         ++outline;
  540.         fprintf(fp, "%s\n", sec[i]);
  541.         }
  542.     }
  543.     }
  544. }
  545.